package com.system.healthproject.model.doctor.service.imp;

import com.system.healthproject.bean.*;
import com.system.healthproject.common.ApiResult;
import com.system.healthproject.mapper.*;
import com.system.healthproject.model.doctor.service.DoctorIlldiscussService;
import com.system.healthproject.pojo.DiscussSingup;
import com.system.healthproject.pojo.Transaction;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;

/**
 * @author Xuheng Zhou
 * @date 2020/6/16 10:01
 * @desc
 */
@Service
@Transactional
public class DoctorIlldiscussServiceImpl implements DoctorIlldiscussService {

    @Autowired
    private IlldiscussMapper mapper;

    @Autowired
    private LoginMapper loginMapper;

    @Autowired
    private DiscussSingupMapper discussSingupMapper;
    @Autowired
    private illdiscussDoctorMapper illdiscussDoctorMapper;

    @Autowired
    private DoctorMapper doctorMapper;
    @Autowired
    private AccountMapper accountMapper;
    @Autowired
    private TransactionMapper transactionMapper;

    @Override
    public Integer selectDoctorIdByLoginId(Integer loginId) {
        return loginMapper.selectDoctorIdByLoginId(loginId);
    }

    @Override
    public List<DoctorIlldiscussBean> selectDoctorIlldiscuss(Integer doctorId, Integer page, Integer size) {
        List<DoctorIlldiscussBean> list=mapper.selectDoctorIlldiscuss(doctorId,(page-1)*size,size);
        if (list.size()>0){
            return list;
        }

        return null;
    }

    @Override
    public List<DoctorIlldiscussBean> selectSpecificDoctorIlldiscuss(Integer doctorId, Integer page, Integer size) {
        return mapper.selectSpecificDoctorIlldiscuss(doctorId,(page-1)*size,size);
    }

    @Override
    public DoctorPayOneIllDiscuss selectPayOneIllDiscussById(Integer illdiscussId) {
        DoctorPayOneIllDiscuss doctorPayOneIllDiscuss=new DoctorPayOneIllDiscuss();
        //通过活动id查询付费的活动详情
        doctorPayOneIllDiscuss=mapper.selectPayOneIllDiscussById(illdiscussId);

        //如果获取是有值的，就把报名人数和邀请嘉宾的人数给查询出来放入进去
        if (doctorPayOneIllDiscuss !=null){
            //查询报名人数
            Integer SiginUpCount=discussSingupMapper.selectDiscussSignUpCount(illdiscussId);
            //查询邀请嘉宾人数
            Integer GuestCount=illdiscussDoctorMapper.selectDisscussGuestCount(illdiscussId);
            doctorPayOneIllDiscuss.setJoinPeopleCount(SiginUpCount+GuestCount);
        }

        return doctorPayOneIllDiscuss;
    }

    @Override
    public DoctorJoinPayOneIllDiscuss selectJoinPayOneIllDiscussById(Integer illdiscussId, Integer doctorId) {

        DoctorJoinPayOneIllDiscuss joinPayOneIllDiscuss=new DoctorJoinPayOneIllDiscuss();
        joinPayOneIllDiscuss=mapper.selectJoinPayOneIllDiscussById(illdiscussId);
        if (joinPayOneIllDiscuss!=null){
            String doctorName=doctorMapper.selectDoctorNameById(doctorId);
            joinPayOneIllDiscuss.setDoctorName(doctorName);
            return joinPayOneIllDiscuss;
        }
        return null;
    }

    @Override
    public boolean addSignUpPayIlldiscuss(Integer doctorId, Integer illdiscussId) {

        //获取活动的费用
        Double costMoney=mapper.selectByPrimaryKey(illdiscussId).getCostMoney();
        //获取活动的主持人
        Integer recordId=mapper.selectByPrimaryKey(illdiscussId).getDoctorId();
        //获取活动的费用类型
        Integer costType=mapper.selectByPrimaryKey(illdiscussId).getCostType();
        //根据报名医生id获取loginid
        Integer signUpLoginId=loginMapper.selectLoginId(doctorId);
        //根据病历探讨主持人id获取登录id
        Integer recordLoginId=loginMapper.selectLoginId(recordId);


        //添加报名信息
        boolean tf=discussSingupMapper.SignUpPayIlldiscuss(illdiscussId,doctorId,new Date())>0?true:false;

        if (tf ==true ){

        //说明是收费，需要添加交易信息
        if ( costMoney>0 && costType==1){
            //查询报名医生的账户金额
            Double accountMoney=accountMapper.selectMoneyByloginId(signUpLoginId);
            //医生账户金额大于活动需要支付的费用
            if (accountMoney>=costMoney) {
                //减少报名医生的账户金额
                boolean tf2 = accountMapper.updateDoctorMoneyByLoginId(signUpLoginId, costMoney) > 0 ? true : false;
                //增加开展病历探讨的医生账户的金额
                boolean tf3=accountMapper.AddMoneyByLoginId(recordLoginId,costMoney)>0?true:false;

                //如果金额增加或减少成功，则添加流水交易信息
                if (tf2==true && tf3==true){
                    Transaction transaction = new Transaction();
                    //付款登录用户id
                    transaction.setLoginId(signUpLoginId);
                    //交易类型 （1、赚取/支付   2、收取   3、消除  ）
                    transaction.setTransactionStatuetype(1);
                    //交易时间
                    transaction.setTransactionTime(new Date());
                    //交易核桃币数量
                    transaction.setTransactionVirtualmoney(costMoney);
                    //收款用户id
                    transaction.setCollectionLoginid(recordLoginId);
                    //交易场景
                    transaction.setTransactionType("报名收费病历探讨活动支付");
                    //交易状态（1成功  2 失败 3待支付）
                    transaction.setTransactionState(1);

                    boolean tf4=transactionMapper.insertSelective(transaction)>0?true:false;

                    Transaction transaction1 = new Transaction();
                    //付款登录用户id
                    transaction1.setLoginId(signUpLoginId);
                    //交易类型 （1、赚取/支付   2、收取   3、消除  ）
                    transaction1.setTransactionStatuetype(1);
                    //交易时间
                    transaction1.setTransactionTime(new Date());
                    //交易核桃币数量
                    transaction1.setTransactionVirtualmoney(costMoney);
                    //收款用户id
                    transaction1.setCollectionLoginid(recordLoginId);
                    //交易场景
                    transaction1.setTransactionType("发起的收费病历探讨活动赚取的一位医生的报名费");
                    //交易状态（1成功  2 失败 3待支付）
                    transaction1.setTransactionState(1);

                    boolean tf5=transactionMapper.insertSelective(transaction1)>0?true:false;

                    //交易信息新增成功
                    if (tf4==true &&tf5==true){
                        //费用支付成功，及报名成功
                        return true;
                    }
                    //交易流水信息增加失败
                    return false;
                }
                //金额增加或减少失败
                return false;
            }
                //您当前账户余额不足！
                return false;
        }else {
            //说明是免费的病历探讨
            return true;
            }
        }
        //直接报名失败
        return false;

    }

    @Override
    public DiscussSingup checkIsSignUp(Integer doctorId, Integer illdiscussId) {
        return discussSingupMapper.checkIsSignUp(doctorId,illdiscussId);
    }

    @Override
    public List<DoctorJoinSuccessPayOneIlldiscuss> selectDoctorJoinSuccessOnePayIllDiscuss(Integer illdiscussId, Integer doctorId) {

        List<DoctorJoinSuccessPayOneIlldiscuss> list=mapper.selectDoctorJoinSuccessOnePayIllDiscuss(illdiscussId);
        if (list.size()>0){
            String doctorName=doctorMapper.selectDoctorNameById(doctorId);
            for (DoctorJoinSuccessPayOneIlldiscuss d:list) {
                d.setDoctorName(doctorName);
            }

            return list;
        }

        return null;
    }

    @Override
    public DoctorRewardOneIllDiscuss selectRewardOneIllDiscussById(Integer illdiscussId) {
        DoctorRewardOneIllDiscuss doctorRewardOneIllDiscuss=new DoctorRewardOneIllDiscuss();
        //通过活动id查询付费的活动详情
        doctorRewardOneIllDiscuss=mapper.selectRewardOneIllDiscussById(illdiscussId);

        //如果获取是有值的，就把报名人数和邀请嘉宾的人数给查询出来放入进去
        if (doctorRewardOneIllDiscuss !=null){
            //查询报名人数
            Integer SiginUpCount=discussSingupMapper.selectDiscussSignUpCount(illdiscussId);
            //查询邀请嘉宾人数
            Integer GuestCount=illdiscussDoctorMapper.selectDisscussGuestCount(illdiscussId);
            doctorRewardOneIllDiscuss.setJoinPeopleCount(SiginUpCount+GuestCount);
        }

        return doctorRewardOneIllDiscuss;
    }

    @Override
    public DoctorJoinRewardOneIllDiscuss selectJoinRewardOneIllDiscussById(Integer illdiscussId, Integer doctorId) {
        DoctorJoinRewardOneIllDiscuss joinRewardOneIllDiscuss=new DoctorJoinRewardOneIllDiscuss();
        joinRewardOneIllDiscuss=mapper.selectJoinRewardOneIllDiscussById(illdiscussId);
        if (joinRewardOneIllDiscuss!=null){
            String doctorName=doctorMapper.selectDoctorNameById(doctorId);
            joinRewardOneIllDiscuss.setDoctorName(doctorName);
            return joinRewardOneIllDiscuss;
        }
        return null;
    }

    @Override
    public boolean addSignUpRewardIlldiscuss(Integer doctorId, Integer illdiscussId) {
        DiscussSingup discussSingup=new DiscussSingup();
        discussSingup.setDoctorId(doctorId);
        discussSingup.setIlldiscussId(illdiscussId);
        discussSingup.setDiscusssingupTime(new Date());
        discussSingup.setJoinState(2);

        return discussSingupMapper.insertSelective(discussSingup)>0?true:false;
    }

    @Override
    public List<DoctorJoinSuccessRewardOneIlldiscuss> selectDoctorJoinSuccessOneRewardIllDiscuss(Integer illdiscussId, Integer doctorId) {
        List<DoctorJoinSuccessRewardOneIlldiscuss> list=mapper.selectDoctorJoinSuccessOneRewardIllDiscuss(illdiscussId);
        if (list.size()>0){
            String doctorName=doctorMapper.selectDoctorNameById(doctorId);
            for (DoctorJoinSuccessRewardOneIlldiscuss d:list) {
                d.setDoctorName(doctorName);
            }

            return list;
        }

        return null;
    }

    @Override
    public boolean doctorClosePayIlldiscuss(Integer illdiscussId, Integer doctorId) {
        //查询探讨的创建人是不是前端的医生id
        Integer illdiscussDoctorId=mapper.selectIllDiscussDoctorIdById(illdiscussId);

        //该活动的创建人id与前端的id相同，说明是想操作该病历探讨
        if (illdiscussDoctorId.equals(doctorId)){
            //改变病历探讨的状态
            boolean tf=mapper.doctorClosePayIlldiscuss(illdiscussId,new Date())>0?true:false;
            if (tf==true){
                return true;
            }
            return false;
        }
        return false;
    }

    @Override
    @Transactional
    public boolean doctorCloseRewardIlldiscuss(Integer illdiscussId, Integer doctorId) {
        //查询探讨的创建人医生id
        Integer illdiscussDoctorId=mapper.selectIllDiscussDoctorIdById(illdiscussId);

        //改变状态，获取奖励费用，然后获取每个医生的id，
        // 再获取每个医生的loginI的，再进行每个医生的账户金额的换算
        boolean tf=false;//判断病历探讨是否改变状态
        boolean tf1 = false;//判断医生账户是否减少
        boolean tf2 = false;//判断医生的交易信息是否增加
        boolean tf3 = false;//判断参会医生的账户是否增加
        boolean tf4 = false;//判断参会医生的交易信息是否增加

        //该活动的创建人id与前端的id相同，说明是想操作该病历探讨
        if (illdiscussDoctorId.equals(doctorId)) {


                //获取观看人数
                Integer watchPersonCount = discussSingupMapper.selectDiscussSignUpCount(illdiscussId);
                //获取病历探讨奖励的核桃币
                Double IlldiscussMoney = mapper.selectIlldiscussMoney(illdiscussId);
                //病历探讨的费用有值，则说明是想操作的病历探讨活动
                if (IlldiscussMoney>0) {
                    //获取报名并且参会的每一位医生的id
                    List<Integer> list = discussSingupMapper.selectSignUpAndJoinDoctorId(illdiscussId);


                    //说明有人观看，就可以进行分钱和添加交易信息
                    if (list.size() > 0 && watchPersonCount > 0) {
                        //获取医生id对应的login的id
                        List<Integer> loginIdList = loginMapper.selectLoginIdByDoctorList(list);
                        //每位观看的医生平分到的核桃币
                        double money = (IlldiscussMoney) / ( watchPersonCount);

                        //添加结束时间，并把状态更改为已结束
                        tf = mapper.doctorCloseRewardIlldiscuss(illdiscussId, new Date()) > 0 ? true : false;
                        //说明患教活动的信息以及更改为已结束，然后计算想要的金额
                        if (tf == true) {

                            Integer loginId=loginMapper.selectLoginId(doctorId);
                            //则医生的金额就对应减少
                            tf1 = accountMapper.updateDoctorMoneyByLoginId(loginId, IlldiscussMoney) > 0 ? true : false;

                            // 则开始增加参会医生账户余额后，再增加相应的交易信息
                            if (tf1 == true) {

                                //把平分的核桃币增加到报名参加的每一位医生的账户上
                                for (Integer DoctorLoginId : loginIdList) {

                                    System.out.println(DoctorLoginId);


                                    Transaction transaction = new Transaction();
                                    //付款登录用户id
                                    transaction.setLoginId(loginId);
                                    //交易类型
                                    transaction.setTransactionStatuetype(1);
                                    //交易时间
                                    transaction.setTransactionTime(new Date());
                                    //交易核桃币数量
                                    transaction.setTransactionVirtualmoney(IlldiscussMoney);
                                    //收款用户id
                                    transaction.setCollectionLoginid(DoctorLoginId);
                                    //交易场景
                                    transaction.setTransactionType("创建的奖励类病历探讨奖励费用");
                                    //交易状态（1成功  2 失败 3待支付）
                                    transaction.setTransactionState(1);


                                    tf2 = transactionMapper.insertSelective(transaction) > 0 ? true : false;

                                    //说明创建医生的账户减少并且已经增加了交易信息，
                                    if (tf2 == true) {
                                        //说明医生的账户金额已经减少了，那么就该增加每一位参会医生的金额
                                        tf3 = accountMapper.updateMoneyByLoginId(DoctorLoginId, money) > 0 ? true : false;
                                        //增加了参会医生的账户余额后，再增加相应的交易信息

                                        Transaction transaction1 = new Transaction();
                                        //付款登录用户id
                                        transaction1.setLoginId(loginId);
                                        //收款用户id
                                        transaction1.setCollectionLoginid(DoctorLoginId);
                                        //交易类型
                                        transaction1.setTransactionStatuetype(1);
                                        //交易时间
                                        transaction1.setTransactionTime(new Date());
                                        //交易核桃币数量
                                        transaction1.setTransactionVirtualmoney(money);
                                        //交易场景
                                        transaction1.setTransactionType("参加病历探讨所赚取的奖励");
                                        //交易状态（1成功  2 失败 3待支付）
                                        transaction1.setTransactionState(1);

                                        //参会医生账户金额结算成功，添加交易信息
                                        if (tf3 == true) {
                                            tf4 = transactionMapper.insertSelective(transaction1) > 0 ? true : false;
                                            if (tf4 == true) {
                                                continue;
                                            } else {
                                                return false;
                                            }
                                        } else {
                                            return false;
                                        }
                                    } else {
                                        return false;
                                    }
                                }
                                //说明for循环结束，已经进行了每一位医生的金额结算和交易信息记录
                                return true;
                            }
                            //主持人的账户扣钱失败
                            return false;
                        }
                        //更改病历探讨的状态失败
                        return false;
                    }
                    //说明没人观看，不用分钱和添加交易信息，直接返回成功
                    return true;
                }
                //该类型不是奖励类型或奖励没有核桃币
                return false;

        }
        return false;
    }

    @Override
    public boolean checkIsEndById(Integer illdiscussId) {
        return mapper.checkIsEndById(illdiscussId)>0?true:false;
    }

    @Override
    public boolean addIllDiscuss(DoctorAddIllDiscussBean doctorAddIllDiscussBean) {

        //判断添加病历探讨和医生的关系数据是否成功
        boolean tf1=false;
        //添加病历探讨的信息
        boolean tf=mapper.doctorAddIllDiscuss(doctorAddIllDiscussBean)>0?true:false;
        //病历探讨添加成功，则添加相应的医生和病历探讨的信息
        if (tf==true) {
            //获取新增的病历探讨的id
            Integer illdiscussId = doctorAddIllDiscussBean.getIlldiscussId();
            //因为参会医生有多个，需要另外对病历探讨与医生的关系进行添加数据
            //解析前台传入的参会医生的id
            for (Integer doctorid : doctorAddIllDiscussBean.getGuestId()) {

                tf1=illdiscussDoctorMapper.insertDiscuss(illdiscussId,doctorid)>0?true:false;
                if (tf1==true){
                    continue;
                }else {
                    return false;
                }

            }
            return true;
        }
        return false;
    }

    @Override
    public DoctorAddSuccessOneIlldiscuss selectDoctorAddSuccessOneIllDiscuss(Integer illdiscussId) {

        return mapper.selectDoctorAddSuccessOneIllDiscuss(illdiscussId);
    }




}
